// 环境配置
const PRODUCTION_CONFIG = {
  BASE_URL: '/api',
  FULL_BASE_URL: import.meta.env.VITE_API_URL || 'http://192.168.0.4:8080/api',
  WEBSOCKET_URL: import.meta.env.VITE_WS_URL || 'ws://192.168.0.4:8080/websocket/screenPushMessage',
  AUTH_TOKEN: import.meta.env.VITE_AUTH_TOKEN || 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ1c2VyMiIsImxvZ2luX3VzZXJfa2V5IjoiMzY5NmNkNDYtYjUzNS00MTcxLTgxMGMtNTBjNDNlM2Y0NWYzIn0.xeMbD-obJ9W3klcxZyKIyBlZZ3RWeBr162TJFvTrfmhbMlADWH0lEEum8pBZ2Ksk33rEUQD8yZXaVgYTBhyn0Q'
};

const DEVELOPMENT_CONFIG = {
  BASE_URL: '/api',
  // FULL_BASE_URL: 'http://192.168.31.195:8080/api',
  // WEBSOCKET_URL: 'ws://192.168.31.195:8080/websocket/screenPushMessage',
  FULL_BASE_URL: 'http://192.168.0.4:8080/api',
  WEBSOCKET_URL: 'ws://192.168.0.4:8080/websocket/screenPushMessage',
  AUTH_TOKEN: 'eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ1c2VyMiIsImxvZ2luX3VzZXJfa2V5IjoiMzY5NmNkNDYtYjUzNS00MTcxLTgxMGMtNTBjNDNlM2Y0NWYzIn0.xeMbD-obJ9W3klcxZyKIyBlZZ3RWeBr162TJFvTrfmhbMlADWH0lEEum8pBZ2Ksk33rEUQD8yZXaVgYTBhyn0Q'
};

// 根据环境选择配置
const API_CONFIG = import.meta.env.PROD ? PRODUCTION_CONFIG : DEVELOPMENT_CONFIG;

// 兼容原有变量名
// 修改兼容变量，统一使用完整地址
const API_BASE_URL = API_CONFIG.FULL_BASE_URL;
const AUTH_TOKEN = API_CONFIG.AUTH_TOKEN;

// 导出配置供外部使用
export { API_CONFIG };

// 配置更新函数
export function updateAPIConfig(newConfig) {
Object.assign(API_CONFIG, newConfig);
console.log('📝 API配置已更新:', API_CONFIG);
}

/**
 * 获取窗口状态
 * @returns {Promise<Object>} 窗口状态数据
 */
export async function getWindowStatus() {
console.log('🔄 开始获取窗口状态...');
try {
const url = `${API_BASE_URL}/screen/window/status`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'GET',
headers: {
'Authorization': AUTH_TOKEN,
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}

const result = await response.json();
console.log('✅ 窗口状态数据:', result);

if (result.code !== 0 && result.code !== 200 && result.code !== 97) {
throw new Error(result.msg || '获取窗口状态失败');
}

return result.data;
} catch (error) {
console.error('❌ 获取窗口状态失败:', error);
console.error('错误详情:', {
message: error.message,
stack: error.stack,
name: error.name
});
throw error;
}
}

/**
 * 获取等候队列
 * @returns {Promise<Array>} 等候队列数据
 */
export async function getWaitList() {
console.log('🔄 开始获取等候队列...');
try {
const url = `${API_BASE_URL}/screen/wait/list`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'GET',
headers: {
'Authorization': AUTH_TOKEN,
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}

const result = await response.json();
console.log('✅ 等候队列数据:', result);

if (result.code !== 0 && result.code !== 200) {
throw new Error(result.msg || '获取等候队列失败');
}

return result.data || [];
} catch (error) {
console.error('❌ 获取等候队列失败:', error);
console.error('错误详情:', {
message: error.message,
stack: error.stack,
name: error.name
});
throw error;
}
}

/**
 * 获取所有部门等候队列
 * @returns {Promise<Array>} 所有部门等候队列数据
 */
export async function getDepartmentWaitAll() {
console.log('🔄 开始获取所有部门等候队列...');
try {
// 使用完整的API地址而不是相对路径
const url = `${API_CONFIG.FULL_BASE_URL}/screen/department/wait/all`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'GET',
headers: {
'Authorization': API_CONFIG.AUTH_TOKEN,
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
console.warn('⚠️ HTTP请求失败，返回空数组');
return [];
}

const result = await response.json();
console.log('✅ 所有部门等候队列数据:', result);

// 如果返回码不是成功状态，静默返回空数组
if (result.code !== 0 && result.code !== 200) {
console.warn('⚠️ API返回非成功状态码:', result.code, result.msg);
return [];
}

return result.data || [];
} catch (error) {
console.warn('⚠️ 获取所有部门等候队列失败，返回空数组:', error.message);
return []; // 静默返回空数组，不抛出错误
}
}

/**
 * 转换部门等候队列数据格式
 * @param {Array} apiData API返回的数据
 * @returns {Array} 转换后的数据
 */
export function transformDepartmentWaitAllData(apiData) {
if (!Array.isArray(apiData)) {
return [];
}

// 按部门分组
const departmentGroups = {};

apiData.forEach(item => {
const deptName = item.departmentName || '未知部门';

if (!departmentGroups[deptName]) {
departmentGroups[deptName] = {
name: deptName,
numbers: []
};
}

if (item.ticketNo) {
departmentGroups[deptName].numbers.push({
n: item.ticketNo,
status: item.status || '等待中',
className: getQueueStatusClass(item.status)
});
}
});

return Object.values(departmentGroups);
}

/**
 * 获取队列状态样式类
 * @param {string} status 状态
 * @returns {string} 样式类名
 */
function getQueueStatusClass(status) {
if (!status) return '';

const statusLower = status.toLowerCase();
if (statusLower.includes('办理') || statusLower.includes('叫号')) {
return 'active';
} else if (statusLower.includes('等待')) {
return 'waiting';
} else if (statusLower.includes('暂停')) {
return 'paused';
}
return '';
}

/**
 * 将窗口状态API数据转换为页面所需格式
 * @param {Array} apiData API返回的数据
 * @returns {Array} 转换后的数据
 */
export function transformWindowData(apiData) {
if (!Array.isArray(apiData)) {
return [];
}

// 按部门分组
const departmentMap = new Map();

apiData.forEach(window => {
const { departmentName, counterName, currentTicketNo, status } = window;

if (!departmentMap.has(departmentName)) {
departmentMap.set(departmentName, {
name: departmentName,
numbers: []
});
}

// 根据实际API返回的status字段进行状态映射
let statusText = '等待中';
let className = 'waiting';

if (typeof status === 'string') {
if (status.includes('忙碌') || status.includes('办理')) {
statusText = '办理中';
className = 'processing';
} else if (status.includes('空闲')) {
statusText = '空闲';
className = 'idle';
} else if (status.includes('暂停')) {
statusText = '暂停';
className = 'paused';
} else {
statusText = status;
className = 'waiting';
}
} else {
switch (status) {
case '0':
case 0:
statusText = '空闲';
className = 'idle';
break;
case '1':
case 1:
statusText = '办理中';
className = 'processing';
break;
case '2':
case 2:
statusText = '暂停';
className = 'paused';
break;
}
}

departmentMap.get(departmentName).numbers.push({
n: currentTicketNo || '无',
status: statusText,
className: className,
counterName: counterName
});
});

return Array.from(departmentMap.values());
}

/**
 * 将等候队列数据转换为页面所需格式
 * @param {Array} waitData 等候队列数据
 * @returns {Array} 转换后的数据
 */
export function transformWaitData(waitData) {
if (!Array.isArray(waitData)) {
return [];
}

// 按部门分组等候队列
const departmentMap = new Map();

waitData.forEach(item => {
const { departmentName, ticketNo } = item;

if (!departmentMap.has(departmentName)) {
departmentMap.set(departmentName, {
name: departmentName,
numbers: []
});
}

departmentMap.get(departmentName).numbers.push({
n: ticketNo || '无',
status: '等待中',
className: 'waiting'
});
});

return Array.from(departmentMap.values());
}

/**
 * 合并窗口状态和等候队列数据
 * @param {Array} windowData 窗口状态数据
 * @param {Array} waitData 等候队列数据
 * @returns {Array} 合并后的数据
 */
export function mergeQueueData(windowData, waitData) {
const windowDepts = transformWindowData(windowData);
const waitDepts = transformWaitData(waitData);

// 创建部门映射
const departmentMap = new Map();

// 先添加窗口状态数据
windowDepts.forEach(dept => {
departmentMap.set(dept.name, {
name: dept.name,
numbers: [...dept.numbers]
});
});

// 再添加等候队列数据
waitDepts.forEach(dept => {
if (departmentMap.has(dept.name)) {
// 如果部门已存在，添加等候队列到现有数据
departmentMap.get(dept.name).numbers.push(...dept.numbers);
} else {
// 如果部门不存在，创建新的部门数据
departmentMap.set(dept.name, dept);
}
});

return Array.from(departmentMap.values());
}

/**
 * 获取完整的队列数据（窗口状态 + 等候队列）
 * @returns {Promise<Array>} 完整的队列数据
 */
export async function getCompleteQueueData() {
console.log('🚀 开始获取完整队列数据...');
try {
// 并行获取两个接口的数据
const [windowData, waitData] = await Promise.all([
getWindowStatus().catch(err => {
console.warn('⚠️ 获取窗口状态失败，使用空数组:', err.message);
return [];
}),
getWaitList().catch(err => {
console.warn('⚠️ 获取等候队列失败，使用空数组:', err.message);
return [];
})
]);

console.log('📊 合并前数据:', { windowData, waitData });
const mergedData = mergeQueueData(windowData, waitData);
console.log('🎯 合并后数据:', mergedData);

return mergedData;
} catch (error) {
console.error('💥 获取完整队列数据失败:', error);
throw error;
}
}

/**
 * 模拟数据（用于测试和备用）
 */
export function getMockData() {
return {
windowData: [
{
counterName: "1号窗口",
currentTicketNo: "A001",
departmentName: "教务处",
status: "1"
},
{
counterName: "2号窗口",
currentTicketNo: "A002",
departmentName: "教务处",
status: "0"
}
],
waitData: [
{
ticketNo: "A003",
departmentName: "教务处"
},
{
ticketNo: "A004",
departmentName: "教务处"
},
{
ticketNo: "B001",
departmentName: "学生处"
}
]
};
}

/**
 * 获取当前叫号信息
 * @returns {Promise<Object>} 当前叫号数据
 */
export async function getCurrentCall() {
console.log('🔄 开始获取当前叫号信息...');
try {
const url = `${API_BASE_URL}/screen/current/call`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'POST',
headers: {
'Authorization': AUTH_TOKEN,
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}

const result = await response.json();
console.log('✅ 当前叫号数据:', result);

if (result.code !== 0 && result.code !== 200) {
throw new Error(result.msg || '获取当前叫号信息失败');
}

return result.data;
} catch (error) {
console.error('❌ 获取当前叫号信息失败:', error);
console.error('错误详情:', {
message: error.message,
stack: error.stack,
name: error.name
});
throw error;
}
}

// 修复 getNoticeList 函数 (大约在第463行)
export async function getNoticeList() {
console.log('🔄 开始获取通知公告详情列表...');
try {
const url = `${API_BASE_URL}/notice/list`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'GET',
headers: {
'Authorization': 'Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ1c2VyOCIsImxvZ2luX3VzZXJfa2V5IjoiZWU3MmJmYjMtYWI5OC00MGYzLTkwYzQtZjlkMGY5ZjdmOWJjIn0.xg3iR-GWuFMD2ZNYiBu7lREO-cWGYHvSdDCTVO6k7Rjwm3RLQ0qrTKe5W49T_w3kHxV1v-wQLs6ELmiwOkXjrg',
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
console.warn('⚠️ HTTP请求失败:', response.status);
return [];
}

const result = await response.json();
console.log('✅ 通知公告详情数据:', result);

// 修复：支持 code: 200 和 code: 0
if (result.code !== 0 && result.code !== 200) {
console.warn('⚠️ API返回错误码:', result.code, result.msg);
return [];
}

return result.data || [];
} catch (error) {
console.warn('⚠️ 获取通知公告详情失败:', error);
return [];
}
}

// 修复 transformNoticeData 函数 (大约在第511行)
export function transformNoticeData(apiData) {
if (!Array.isArray(apiData)) {
return [];
}

return apiData.map((item, index) => ({
// 使用索引作为ID，如果没有noticeId字段
id: item.noticeId || item.id || index,
title: item.noticeTitle || '无标题',
type: item.noticeType === '1' ? '通知' : item.noticeType === '2' ? '公告' : '其他',
// 如果没有noticeContent，使用noticeTitle作为内容
content: item.noticeContent || item.content || item.noticeTitle || '暂无内容',
startTime: item.startTime || item.createTime || '',
endTime: item.endTime || '',
deptId: item.deptId || item.departmentId || 0,
status: item.status || '1',
// 格式化显示用的日期
displayDate: item.startTime ? new Date(item.startTime).toLocaleDateString('zh-CN') : 
                 item.createTime ? new Date(item.createTime).toLocaleDateString('zh-CN') : 
                 new Date().toLocaleDateString('zh-CN')
}));
}

/**
 * 获取通知公告列表
 * @param {number} page 页码，默认为1
 * @param {number} pageSize 每页数量，默认为10
 * @returns {Promise<Object>} 通知公告数据
 */
export async function getAnnouncementList(page = 1, pageSize = 10) {
console.log('🔄 开始获取通知公告列表...');
try {
const url = `${API_BASE_URL}/screen?page=${page}&pageSize=${pageSize}`;
console.log('📡 请求URL:', url);

const response = await fetch(url, {
method: 'GET',
headers: {
'Authorization': AUTH_TOKEN,
'Content-Type': 'application/json'
}
});

console.log('📥 响应状态:', response.status, response.statusText);

if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}

const result = await response.json();
console.log('✅ 通知公告数据:', result);

if (result.code !== 0 && result.code !== 200) {
throw new Error(result.msg || '获取通知公告列表失败');
}

return result.data || [];
} catch (error) {
console.error('❌ 获取通知公告列表失败:', error);
console.error('错误详情:', {
message: error.message,
stack: error.stack,
name: error.name
});
throw error;
}
}

/**
 * 统一WebSocket数据服务
 * 支持dataType: 0-当前大屏所有信息, 1-当前叫号信息, 2-当前窗口状态信息, 
 * 3-当前等待队列信息, 4-通知公告, 5-当前部门等候人数信息
 */

/**
 * WebSocket连接管理类
 */
class WebSocketManager {
constructor() {
this.ws = null;
this.reconnectAttempts = 0;
this.maxReconnectAttempts = 5;
this.reconnectInterval = 3000;
this.listeners = new Map();
this.dataHandlers = new Map();
}

  /**
   * 连接WebSocket
   * @param {string} url WebSocket地址
   */
  connect(url = API_CONFIG.WEBSOCKET_URL) {
    try {
      console.log('🔌 正在连接WebSocket:', url);
      this.ws = new WebSocket(url);
      
      this.ws.onopen = () => {
        console.log('✅ WebSocket连接成功');
        this.reconnectAttempts = 0;
        this.notifyListeners('connected', { status: 'connected' });
      };
      
      this.ws.onmessage = (event) => {
        try {
          const data = JSON.parse(event.data);
          console.log('📨 收到WebSocket消息:', data);
          this.handleMessage(data);
        } catch (error) {
          console.error('❌ 解析WebSocket消息失败:', error);
        }
      };
      
      this.ws.onclose = (event) => {
        console.log('🔌 WebSocket连接关闭:', event.code, event.reason);
        this.notifyListeners('disconnected', { code: event.code, reason: event.reason });
        this.handleReconnect();
      };
      
      this.ws.onerror = (error) => {
        console.error('❌ WebSocket连接错误:', error);
        this.notifyListeners('error', error);
      };
    } catch (error) {
      console.error('❌ WebSocket连接失败:', error);
      this.handleReconnect();
    }
  }

/**
 * 处理WebSocket消息
 * @param {Object} data 消息数据
 */
handleMessage(data) {
const { dataType } = data;
console.log('🔄 处理WebSocket消息，dataType:', dataType);

// 根据dataType分发消息
switch (dataType) {
case '0': // 当前大屏所有信息
// 修复：直接使用dataType作为键，而不是'allData'
this.notifyDataHandlers('0', data);
break;
case '1': // 当前叫号信息
this.notifyDataHandlers('1', data.currentCallData);
break;
case '2': // 当前窗口状态信息
this.notifyDataHandlers('2', data.currentWinData);
break;
case '3': // 当前等待队列信息
this.notifyDataHandlers('3', data.currentWaitData);
break;
case '4': // 通知公告
this.notifyDataHandlers('4', data.currentNoiceData);
break;
case '5': // 当前部门等候人数信息
this.notifyDataHandlers('5', data.currentDeptWaitData);
break;
default:
console.warn('⚠️ 未知的数据类型:', dataType);
this.notifyListeners('message', data);
}
}

/**
 * 处理重连
 */
handleReconnect() {
if (this.reconnectAttempts < this.maxReconnectAttempts) {
this.reconnectAttempts++;
console.log(`🔄 尝试重连WebSocket (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
setTimeout(() => {
this.connect();
}, this.reconnectInterval);
} else {
console.error('❌ WebSocket重连失败，已达到最大重试次数');
this.notifyListeners('reconnectFailed', { attempts: this.reconnectAttempts });
}
}

/**
 * 添加事件监听器
 * @param {string} event 事件名称
 * @param {Function} callback 回调函数
 */
addEventListener(event, callback) {
if (!this.listeners.has(event)) {
this.listeners.set(event, []);
}
this.listeners.get(event).push(callback);
}

/**
 * 添加数据处理器
 * @param {string} dataType 数据类型
 * @param {Function} handler 处理函数
 */
addDataHandler(dataType, handler) {
if (!this.dataHandlers.has(dataType)) {
this.dataHandlers.set(dataType, []);
}
this.dataHandlers.get(dataType).push(handler);
}

/**
 * 移除数据处理器
 * @param {string} dataType 数据类型
 * @param {Function} handler 处理函数
 */
removeDataHandler(dataType, handler) {
if (this.dataHandlers.has(dataType)) {
const handlers = this.dataHandlers.get(dataType);
const index = handlers.indexOf(handler);
if (index > -1) {
handlers.splice(index, 1);
}
}
}

/**
 * 通知数据处理器
 * @param {string} dataType 数据类型
 * @param {any} data 数据
 */
notifyDataHandlers(dataType, data) {
if (this.dataHandlers.has(dataType)) {
this.dataHandlers.get(dataType).forEach(handler => {
try {
handler(data);
} catch (error) {
console.error('❌ 数据处理器执行失败:', error);
}
});
}
}

/**
 * 移除事件监听器
 * @param {string} event 事件名称
 * @param {Function} callback 回调函数
 */
removeEventListener(event, callback) {
if (this.listeners.has(event)) {
const callbacks = this.listeners.get(event);
const index = callbacks.indexOf(callback);
if (index > -1) {
callbacks.splice(index, 1);
}
}
}

/**
 * 通知监听器
 * @param {string} event 事件名称
 * @param {any} data 数据
 */
notifyListeners(event, data) {
if (this.listeners.has(event)) {
this.listeners.get(event).forEach(callback => {
try {
callback(data);
} catch (error) {
console.error('❌ 事件监听器执行失败:', error);
}
});
}
}

/**
 * 发送消息
 * @param {any} data 要发送的数据
 */
send(data) {
if (this.ws && this.ws.readyState === WebSocket.OPEN) {
this.ws.send(JSON.stringify(data));
} else {
console.warn('⚠️ WebSocket未连接，无法发送消息');
}
}

/**
 * 关闭连接
 */
disconnect() {
if (this.ws) {
this.ws.close();
this.ws = null;
}
this.listeners.clear();
this.dataHandlers.clear();
}

/**
 * 获取连接状态
 */
getReadyState() {
return this.ws ? this.ws.readyState : WebSocket.CLOSED;
}
}

// 创建全局WebSocket管理器实例
export const wsManager = new WebSocketManager();

/**
 * 初始化WebSocket连接
 * @param {Object} handlers 数据处理器对象
 * @param {Function} handlers.onCurrentCall 当前叫号数据处理器
 * @param {Function} handlers.onWindowStatus 窗口状态数据处理器
 * @param {Function} handlers.onWaitQueue 等待队列数据处理器
 * @param {Function} handlers.onAnnouncements 通知公告数据处理器
 * @param {Function} handlers.onDepartmentWaiting 部门等候数据处理器
 * @param {Function} handlers.onAllData 所有数据处理器
 * @param {Function} onError 错误处理器
 */
export function initWebSocket(handlers = {}, onError) {
console.log('🚀 初始化WebSocket连接');

return new Promise((resolve, reject) => {
// 注册数据处理器
Object.keys(handlers).forEach(dataType => {
if (handlers[dataType]) {
wsManager.addDataHandler(dataType, handlers[dataType]);
}
});

// 监听连接事件
wsManager.addEventListener('connected', () => {
console.log('✅ WebSocket连接成功');
resolve(); // 连接成功时resolve Promise
});

wsManager.addEventListener('disconnected', () => {
console.log('🔌 WebSocket连接断开');
});

wsManager.addEventListener('error', (error) => {
console.error('❌ WebSocket错误:', error);
if (onError) onError(error);
reject(error); // 连接错误时reject Promise
});

wsManager.addEventListener('reconnectFailed', () => {
console.error('❌ WebSocket重连失败');
const error = new Error('WebSocket重连失败');
if (onError) onError(error);
reject(error);
});

// 开始连接
try {
wsManager.connect();
} catch (error) {
reject(error);
}
});
}

/**
 * 关闭WebSocket连接
 */
export function closeWebSocket() {
console.log('🔌 关闭WebSocket连接');
wsManager.disconnect();
}

/**
 * 数据转换工具函数
 */

/**
 * 转换当前叫号数据
 * @param {Object} data 原始数据
 * @returns {Object} 转换后的数据
 */
export function transformCurrentCallData(data) {
if (!data) return null;

return {
counterName: data.counterName || '',
currentTicketNo: data.currentTicketNo || '',
departmentName: data.departmentName || ''
};
}

/**
 * 转换窗口状态数据
 * @param {Array} data 原始数据
 * @returns {Array} 转换后的数据
 */
export function transformWindowStatusData(data) {
if (!Array.isArray(data)) return [];

return data.map(item => ({
counterName: item.counterName || '',
currentTicketNo: item.currentTicketNo || '',
departmentName: item.departmentName || '',
status: item.status || '0' // 0空闲 1忙碌中 2暂停
}));
}

/**
 * 转换等待队列数据
 * @param {Array} data 原始数据
 * @returns {Array} 转换后的数据
 */
export function transformWaitQueueData(data) {
if (!Array.isArray(data)) return [];

return data.map(item => ({
ticketNo: item.ticketNo || '',
departmentName: item.departmentName || ''
}));
}

/**
 * 转换通知公告数据
 * @param {Array} data 原始数据
 * @returns {Array} 转换后的数据
 */
export function transformAnnouncementsData(data) {
if (!Array.isArray(data)) return [];

return data.map(item => ({
noticeId: item.noticeId || 0,
noticeTitle: item.noticeTitle || '',
startTime: item.startTime || ''
}));
}

/**
 * 转换部门等候数据
 * @param {Array} data 原始数据
 * @returns {Array} 转换后的数据
 */
export function transformDepartmentWaitingData(data) {
if (!Array.isArray(data)) return [];

return data.map(item => ({
departmentId: item.departmentId || 0,
departmentName: item.departmentName || '',
waitingCount: item.waitingCount || 0
}));
}

/**
 * 获取窗口状态文本
 * @param {string} status 状态码
 * @returns {string} 状态文本
 */
export function getStatusText(status) {
switch (status) {
case '0': return '空闲';
case '1': return '忙碌中';
case '2': return '暂停';
default: return '未知';
}
}

/**
 * 获取窗口状态样式类
 * @param {string} status 状态码
 * @returns {string} 样式类名
 */
export function getStatusClass(status) {
switch (status) {
case '0': return 'status-idle';
case '1': return 'status-busy';
case '2': return 'status-pause';
default: return 'status-unknown';
}
}

/**
 * 获取部门图标
 * @param {string} departmentName 部门名称
 * @returns {string} 图标类名
 */
export function getDepartmentIcon(departmentName) {
const iconMap = {
'教务处': '📚',
'学生处': '👥',
'财务处': '💰',
'人事处': '👤',
'后勤处': '🔧',
'保卫处': '🛡️',
'图书馆': '📖',
'实验室': '🔬'
};
return iconMap[departmentName] || '🏢';
}
